{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Python期中总结"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'IDE': {'IDLE': 'IDLE是Python的内置IDE，可以用来实验和执行Python代码，这可以是但语句代码段，也可以是IDLE的文本编辑器中编写的更大的多语句程序。', 'JUPYTE': '作为数据科学家最喜欢使用的Python编辑器，兼具脚本操作和交互式操作的特性', 'pycharm': '已经成为我们目前学习Python使用的最重要的IDE工具。我们能够从操作系统的命令行直接运行python代码文件'}, '函数 + 模块 = 标准库': {'从标准库导入函数': 'from os(标准库模块) import getcwd(函数)', '调用模块': 'where_am_I = getcwd()--根据需要调用', '模块及用法:': {'datetime': {'导入datetime模块': 'import datetime', 'date.today函数提供今天的日期': 'datetime.data.today()', 'date.today后加一个要访问的属性单独访问日，月和年值': 'datetime.data.today() .day(month/year)', '调用date.isoformat函数并传入今天日期，日期转换成字符串': 'datetime.date.isoformat(datetime.date.today())'}, 'time': {'导入time模块': 'import time', 'strftime函数可以指定你想以什么方式显示时间': 'time.strftime() ----填的是%H:%M 24小时制当小时（%H）和分钟（%M）', '星期几，上下午': '星期 %A,上下午 %P'}}}, '四个内置数据结构': {'列表 list': {'基本': {'是有序的可变对象集合': '列表中的每一个槽（元素）从0开始编号', '是动态的': '可以根据需要扩展和收缩', '是异构的': '一个列表可以混合不同类型的对象', '是可变的': '可以在任何时间通过增加，删除或修改对象来修改列表'}, '书写': {'列表认识开始、结束和步长值': 'letters[start:stop:step]  ', '列表用中括号包围，包含的对象之间用逗号隔开': \"   odds = [1,2,3,3,5,6]  或者  odds = ['a', 'e', 'i', 'a']     ----odds是变量，[1,2,3...],['a', 'e', 'i', 'o'] 是列表\", '可以同时含有数字和字母，且可以重复': \"    odds = [1,2,'w','a']  或   odds = ['q','d','s',4,6,6]  \", '类似于字符串，浮点数和整数，列表本身也是对象': {'包含列表对象的列表': \"     everything = [ prices, temps, words]   或    everything = [ prices, 2,3, 'w']     \", '包含列表中的列表': \"      odds_and_ends = [ [1,2,3,4], ['a', 'e', 'i', 'a'] ]   或     odds_and_ends = [ [1,2,,4], ['a', 'i', 'a'] ,1,2,'a','q']   \", '假设列表': \"   names = [ 'a','b','c','d']    \", '查询（切片）': {'取出第一个值': '   names[0]   ', '取出最后一个值': '    names[-1]   ', '取出某个值': '   names[1]    ', '取出中间一些连续的值（还是列表 )': '   names[1:3]   ------“取左不取右”取出第二个和第三个', '从后往前取出一些值（还是列表）': '    names[-3:-1]    -------“小数在前，大数在后”取出倒数第二个和倒数第三个', '取到最后一个值': '    names[-3: ]   ', '取到第三个值': '    names[ :4]   -------------第一个值和最后一个都可以不写，即“0”和“-1”都可省略  '}, '增删改': {'增加': {'append增加最后一个': '   names.append ()   ', '    insert指定位置增加数据': '   names.insert(1,)    '}, '删除': {'pop删除最后一个': '  names.pop()   -------()内不填时代表删除最后一个，填了等于del    ', '   del删除指定某个位置的数据': '    names.del(1)     ------- names.pop(1)  ', '   remove删除某个数据': '   names.remove()   '}, '修改': {'直接找到列表中某个值，然后赋新值': '     names[]     '}}, '列表的复制': {'copy复制': '   second = [1,2,3,4,5]      third = second.copy()     ', '利用切片': '   a = [1,2,3,4]      b = a[:]     '}}}}, '元组 tuple': {'是有序的不可变对象集合': '一旦向一个元组赋对象，任何情况下这个元组都不能再改变。', '是一个不可变的列表': '通常可以把元组想象成一个常量列表', '方法': {'假设元组': '  a = (1,2,3,4,4,5,6,7,2) ', 'count 统计出现次数': '   print(a.count(4))  ', 'index 查询位置，排在第几个': '   print(a.index(4))  '}, 'while 循环': {'一直循环，利用count增加次数': '     count +=1    '}}, '字典 dict': {'别名': '关联数组，映射，符号表或散列。', '是无序的键/值对集合': '在字典中每个唯一键有一个与之关联的值（可以是任何对象），字典可以包含多个键/值对。值可改，键不可改', '是动态的': '可以根据需要扩展和收缩', '是无序且可变的': '可以在任何时间通过增加键/值对，但字典不会保持这个顺序', '方法': {'假设字典': '   info = {:,: }  ', '增加': '       info[] =     -----直接打就行，位置是随意的  D[k] =d', '修改': '       info[] =     -----直接打你想要修改的键= 值（修改）', '删除': {'pop 标准删除': '     info.pop()   填的是键    ', 'popitem 随机删除': '     info.popitem()      ', 'del 删除': '      del info()   填的是键  '}, '查找': {'标准用法': '      in info     填的是键        ', '获取': '        info[]   ------填的是键，但如果一个key不存在，就报错，get不会，不存在只返回None    ', 'get 获取': '       info.get()  ----填的是键，较正确做法  ', '所有的键': '       info.keys()        ----所有的键  ', '数据的值': '     info.values()      -----数据可视化分析   ', 'setdefault': '      info.setdefault()    --------判断一个值是否存在，不存在，就增加进去'}}}, '集合  sets': {'集合是无序的唯一对象集合': '可以用来保存相关对象的一个集合，同时确保其中任何对象不会重复。', '是动态的': '可以根据需要扩展和收缩', '操作': {'并集': {'方法一:   .union': '      list_2 .union(list_3)        ', '方法二:   |   ': '   list_2 | list_3   '}, '交集': {' 方法一： .intersection': '      list_3 .intersection(list_3 )     ', '方法二: &': '     list_2 & list_3      '}, '差集': {'方法一： .difference': '     list_2 .difference(list_3 )  ', '方法二：-': '      list_2 - list_3 '}, '对称差集': '       list_2 .symmetric_difference(list_3 )        -----减完两个集合剩下的数  或者 做两个差集，两个差集再做并集', '子集': '     list_2 .issubset(list_3 )   -----2是3的子集？是-True,否-False   T  ', '父集': '     list_2 .issuperset(list_3)    '}}}, '函数': {'方法': '1,定义一个函数：def  2,函数名：有意义name  3,参数： 4,注释：有意义，（别人调用（help（name）查看具体函数应用))  5,代码块：print()  没有print（） 6,返回值：return （返回一个简单值（对象），也可返回多个值（打包成元组））', '参数': '形参（位置关键参数），实参（默认参数） 关键字参数=默认参数  比如a=6,要放在后边', 'def test3(a,**kwargs):': '   *args 输入：多个参数值（位置参数），输出：一个元组的形式  ', 'def test3(a,*args):': '   **kwargs  输入：关键字参数（dict字典）输出：字典  '}}\n"
     ]
    }
   ],
   "source": [
    "#author：Chen Zhili\n",
    "\n",
    "python_base = {\"IDE\": {\n",
    "    \"IDLE\": \"IDLE是Python的内置IDE，可以用来实验和执行Python代码，这可以是但语句代码段，也可以是IDLE的文本编辑器中编写的更大的多语句程序。\",\n",
    "    \"JUPYTE\": \"作为数据科学家最喜欢使用的Python编辑器，兼具脚本操作和交互式操作的特性\",\n",
    "    \"pycharm\": \"已经成为我们目前学习Python使用的最重要的IDE工具。我们能够从操作系统的命令行直接运行python代码文件\", },\n",
    "    \"函数 + 模块 = 标准库\": {\n",
    "        \"从标准库导入函数\": \"from os(标准库模块) import getcwd(函数)\",\n",
    "        \"调用模块\": \"where_am_I = getcwd()--根据需要调用\",\n",
    "        \"模块及用法:\": {\n",
    "            \"datetime\": {\n",
    "                \"导入datetime模块\": \"import datetime\",\n",
    "                \"date.today函数提供今天的日期\": \"datetime.data.today()\",\n",
    "                \"date.today后加一个要访问的属性单独访问日，月和年值\": \"datetime.data.today() .day(month/year)\",\n",
    "                \"调用date.isoformat函数并传入今天日期，日期转换成字符串\": \"datetime.date.isoformat(datetime.date.today())\",\n",
    "            },\n",
    "            \"time\": {\n",
    "                \"导入time模块\": \"import time\",\n",
    "                \"strftime函数可以指定你想以什么方式显示时间\": \"time.strftime(\" \") ----填的是%H:%M 24小时制当小时（%H）和分钟（%M）\",\n",
    "                \"星期几，上下午\": \"星期 %A,上下午 %P\"\n",
    "            },\n",
    "        }},\n",
    "    \"四个内置数据结构\": {\n",
    "        \"列表 list\": {\n",
    "            \"基本\": {\n",
    "                \"是有序的可变对象集合\": \"列表中的每一个槽（元素）从0开始编号\",\n",
    "                \"是动态的\": \"可以根据需要扩展和收缩\",\n",
    "                \"是异构的\": \"一个列表可以混合不同类型的对象\",\n",
    "                \"是可变的\": \"可以在任何时间通过增加，删除或修改对象来修改列表\"\n",
    "            },\n",
    "        \"书写\": {\n",
    "            \"列表认识开始、结束和步长值\": \"letters[start:stop:step]  \",\n",
    "            \"列表用中括号包围，包含的对象之间用逗号隔开\": \"   odds = [1,2,3,3,5,6]  或者  odds = ['a', 'e', 'i', 'a']     ----odds是变量，[1,2,3...],['a', 'e', 'i', 'o'] 是列表\",\n",
    "            \"可以同时含有数字和字母，且可以重复\": \"    odds = [1,2,'w','a']  或   odds = ['q','d','s',4,6,6]  \",\n",
    "            \"类似于字符串，浮点数和整数，列表本身也是对象\": {\n",
    "                \"包含列表对象的列表\": \"     everything = [ prices, temps, words]   或    everything = [ prices, 2,3, 'w']     \",\n",
    "                \"包含列表中的列表\": \"      odds_and_ends = [ [1,2,3,4], ['a', 'e', 'i', 'a'] ]   或     odds_and_ends = [ [1,2,,4], ['a', 'i', 'a'] ,1,2,'a','q']   \",\n",
    "                \"假设列表\": \"   names = [ 'a','b','c','d']    \",\n",
    "                \"查询（切片）\": {\n",
    "                    \"取出第一个值\": \"   names[0]   \",\n",
    "                    \"取出最后一个值\": \"    names[-1]   \",\n",
    "                    \"取出某个值\": \"   names[1]    \",\n",
    "                    \"取出中间一些连续的值（还是列表 )\": \"   names[1:3]   ------“取左不取右”取出第二个和第三个\",\n",
    "                    \"从后往前取出一些值（还是列表）\": \"    names[-3:-1]    -------“小数在前，大数在后”取出倒数第二个和倒数第三个\",\n",
    "                    \"取到最后一个值\": \"    names[-3: ]   \",\n",
    "                    \"取到第三个值\": \"    names[ :4]   -------------第一个值和最后一个都可以不写，即“0”和“-1”都可省略  \"},\n",
    "                \"增删改\": {\n",
    "                    \"增加\": {\"append增加最后一个\": \"   names.append (\"\")   \",\n",
    "                           \"    insert指定位置增加数据\": \"   names.insert(1,\"\")    \"},\n",
    "                    \"删除\": {\"pop删除最后一个\": \"  names.pop()   -------()内不填时代表删除最后一个，填了等于del    \",\n",
    "                           \"   del删除指定某个位置的数据\": \"    names.del(1)     ------- names.pop(1)  \",\n",
    "                           \"   remove删除某个数据\": \"   names.remove(\"\")   \"},\n",
    "                    \"修改\": {\"直接找到列表中某个值，然后赋新值\": \"     names[\"\"]     \"}},\n",
    "\n",
    "                \"列表的复制\": {\n",
    "                    \"copy复制\": \"   second = [1,2,3,4,5]      third = second.copy()     \",\n",
    "                    \"利用切片\": \"   a = [1,2,3,4]      b = a[:]     \"}}}},\n",
    "\n",
    "            \"元组 tuple\": {\n",
    "                \"是有序的不可变对象集合\": \"一旦向一个元组赋对象，任何情况下这个元组都不能再改变。\",\n",
    "                \"是一个不可变的列表\": \"通常可以把元组想象成一个常量列表\",\n",
    "                \"方法\": {\n",
    "                    \"假设元组\": \"  a = (1,2,3,4,4,5,6,7,2) \",\n",
    "                    \"count 统计出现次数\": \"   print(a.count(4))  \",\n",
    "                    \"index 查询位置，排在第几个\": \"   print(a.index(4))  \"\n",
    "                },\n",
    "                \"while 循环\": {\"一直循环，利用count增加次数\": \"     count +=1    \"\n",
    "                             }},\n",
    "\n",
    "            \"字典 dict\": {\n",
    "                \"别名\": \"关联数组，映射，符号表或散列。\",\n",
    "                \"是无序的键/值对集合\": \"在字典中每个唯一键有一个与之关联的值（可以是任何对象），字典可以包含多个键/值对。值可改，键不可改\",\n",
    "                \"是动态的\": \"可以根据需要扩展和收缩\",\n",
    "                \"是无序且可变的\": \"可以在任何时间通过增加键/值对，但字典不会保持这个顺序\",\n",
    "                \"方法\": {\n",
    "                    \"假设字典\": \"   info = {\" \":\" \",\" \":\" \" }  \",\n",
    "                    \"增加\": \"       info[\" \"] = \" \"    -----直接打就行，位置是随意的  D[k] =d\",\n",
    "                    \"修改\": \"       info[\"\"] = \"\"    -----直接打你想要修改的键= 值（修改）\",\n",
    "                    \"删除\": {\n",
    "                        \"pop 标准删除\": \"     info.pop(\"\")   填的是键    \",\n",
    "                        \"popitem 随机删除\": \"     info.popitem()      \",\n",
    "                        \"del 删除\": \"      del info(\" \")   填的是键  \"},\n",
    "                    \"查找\": {\n",
    "                        \"标准用法\": \"     \" \" in info     填的是键        \",\n",
    "                        \"获取\": \"        info[\" \"]   ------填的是键，但如果一个key不存在，就报错，get不会，不存在只返回None    \",\n",
    "                        \"get 获取\": \"       info.get(\" \")  ----填的是键，较正确做法  \",\n",
    "                        \"所有的键\": \"       info.keys()        ----所有的键  \",\n",
    "                        \"数据的值\": \"     info.values()      -----数据可视化分析   \",\n",
    "                        \"setdefault\": \"      info.setdefault()    --------判断一个值是否存在，不存在，就增加进去\"\n",
    "                    }}},\n",
    "                \"集合  sets\": {\n",
    "                    \"集合是无序的唯一对象集合\": \"可以用来保存相关对象的一个集合，同时确保其中任何对象不会重复。\",\n",
    "                    \"是动态的\": \"可以根据需要扩展和收缩\",\n",
    "                    \"操作\": {\n",
    "                        \"并集\": {\n",
    "                            \"方法一:   .union\": \"      list_2 .union(list_3)        \",\n",
    "                            \"方法二:   |   \": \"   list_2 | list_3   \"},\n",
    "                        \"交集\": {\" 方法一： .intersection\": \"      list_3 .intersection(list_3 )     \",\n",
    "                               \"方法二: &\": \"     list_2 & list_3      \"},\n",
    "                        \"差集\": {\"方法一： .difference\": \"     list_2 .difference(list_3 )  \",\n",
    "                               \"方法二：-\": \"      list_2 - list_3 \"},\n",
    "                        \"对称差集\": \"       list_2 .symmetric_difference(list_3 )        -----减完两个集合剩下的数  或者 做两个差集，两个差集再做并集\",\n",
    "                        \"子集\": \"     list_2 .issubset(list_3 )   -----2是3的子集？是-True,否-False   T  \",\n",
    "                        \"父集\": \"     list_2 .issuperset(list_3)    \"\n",
    "                    }}},\n",
    "            \"函数\": {\n",
    "                \"方法\": \"1,定义一个函数：def  2,函数名：有意义name  3,参数： 4,注释：有意义，（别人调用（help（name）查看具体函数应用))  5,代码块：print()  没有print（） 6,返回值：return （返回一个简单值（对象），也可返回多个值（打包成元组））\",\n",
    "                \"参数\": \"形参（位置关键参数），实参（默认参数） 关键字参数=默认参数  比如a=6,要放在后边\",\n",
    "                \"def test3(a,**kwargs):\": \"   *args 输入：多个参数值（位置参数），输出：一个元组的形式  \",\n",
    "                \"def test3(a,*args):\": \"   **kwargs  输入：关键字参数（dict字典）输出：字典  \"\n",
    "                     }\n",
    "        }\n",
    "\n",
    "print(python_base)        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
